In recent years, apparatuses in conformity with the system such as MPEG in which image information are dealt as digital information to compress such image information by orthogonal transform such as discrete cosine transform, etc. and motion prediction/compensation by utilizing redundancy specific to image information for the purpose of realizing transmission/storage of information having high efficiency in that instance are being popularized at both information distribution (delivery) at broadcasting station, etc. and information reception in general homes.
Particularly, the MPEG2 (ISO/IEC 13818-2) is defined as general purpose image encoding system, and is widely used at present in broad application for professional use purpose and consumer use purpose at the standard where both interlaced scanning image and sequential scanning image, and standard resolution image and high definition image are covered. By using the MPEG2 compression system, in the case of interlaced scanning image of the standard resolution having, e.g., 720×480 pixels, code quantity (bit rate) of 4 to 8 Mbps is assigned, and in the case of interlaced scanning image of high resolution having 1920×1088 pixels, code quantity (bit rate) of 18 to 22 Mbps is assigned so that high compression factor and satisfactory picture quality can be realized.
The MPEG2 is mainly directed to high picture quality encoding adapted mainly to encoding system for broadcast, but did not comply with encoding system having code quantity (bit rate) lower than that of the MPEG1, i.e., compression factor higher than that. However, it is deemed that needs of such encoding system will be increased in future with popularization of portable (mobile) terminals. In correspondence therewith, standardization of the MPEG4 encoding system has been performed. In connection with the image encoding system, its standard has been approved as the International Standard as ISO/IEC 14496-2 on December, 1998.
Further, in recent years, with realization of image encoding for television conference being as the object in the beginning, standardization of H.264 (ITU-TQ6/16 VCEG) is being developed. It is known that while the H.264 requires a larger number of operation quantities for encoding/decoding thereof as compared to the conventional encoding system such as MPEG2 or MPEG4, higher encoding efficiency can be realized. In addition, standardization in which functions which cannot be supported by H.264 are also taken in with the H.264 being as base to realize higher encoding efficiency is being performed at present by JVT (Joint Video Team) as a part of activity of the MPEG4.
Here, outline of the configuration of an image information encoding apparatus adapted for realizing image compression by orthogonal transform such as discrete cosine transform or Karhnen-Loueve transform, etc. and motion prediction/compensation is shown in FIG. 1. As shown in FIG. 1, the image information encoding apparatus 100 comprises an A/D (Analogue/Digital) converting unit 101, an image sorting buffer 102, an adder 103, an orthogonal transform unit 104, a quantization unit 105, a reversible encoding unit 106, a storage buffer 107, an inverse quantization unit 108, an inverse orthogonal transform unit 109, an adder 110, a frame memory 111, a motion prediction/compensation unit 112, an intra prediction unit 113, and a rate control unit 114.
In FIG. 1, the A/D converting unit 101 converts an inputted image signal into a digital signal. The image sorting buffer 102 performs sorting of frames in accordance with GOP (Group of Pictures) structure of image compressed information outputted from the image information encoding apparatus 100.
In this example, the image sorting buffer 102 delivers image information of the entirety of frames to the orthogonal transform unit 104 in regard to images in which intra (intra-image) encoding is performed. The orthogonal transform unit 104 implements orthogonal transform such as discrete cosine transform or Karhnen-Loueve transform, etc. to image information to deliver transform coefficients to the quantization unit 105. The quantization unit 105 implements quantization processing to the transform coefficients which have been delivered from the orthogonal transform unit 104.
The reversible encoding unit 106 implements reversible encoding such as variable length encoding or arithmetic encoding, etc. to the quantized transform coefficients to deliver the encoded transform coefficients to the storage buffer 107 to store them thereinto. The encoded transform coefficients thus obtained are outputted as image compressed information.
The behavior (operation) of the quantization unit 105 is controlled by the rate control unit 114. Moreover, the quantization unit 105 delivers quantized transform coefficients to the inverse quantization unit 108. The inverse quantization unit 108 inverse-quantizes the transform coefficients thus delivered. The inverse orthogonal transform unit 109 implements inverse orthogonal transform processing to the inverse-quantized transform coefficients to generate decoded image information to deliver the information thus generated to the frame memory 111 to store them thereinto.
On the other hand, the image sorting buffer 102 delivers image information to the motion prediction/compensation unit 112 in regard to images in which inter (inter-image) encoding is performed. The motion prediction/compensation unit 112 takes out image information referred at the same time from the frame memory 111 to implement motion prediction/compensation processing thereto to generate reference image information. The motion prediction/compensation unit 112 delivers the reference image information thus generated to the adder 103. The adder 103 converts the reference image information into a difference signal between the reference image information and the image information thus delivered. In addition, the motion compensation/prediction unit 112 delivers motion vector information to the reversible encoding unit 106 at the same time.
The reversible encoding unit 106 implements reversible encoding processing such as variable length encoding or arithmetic encoding, etc. to the motion vector information thus delivered to form information inserted into the header portion of the image compressed information. It is to be noted that since other processing are the same as those of image compressed information to which intra-encoding is implemented, their explanation will be omitted.
Here, in the encoding system in which standardization is performed by the above-described JVT (hereinafter referred to as JVT Codec), there is employed intra-predictive encoding such that predictive images are generated from pixels around block in performing intra-encoding to encode difference therebetween. Namely, in regard to images in which intra-encoding is performed, prediction images are generated from pixel values in which encoding has been already completed in the vicinity of pixel block to be encoded so that differences with respect to the predictive images thereof are encoded. The inverse quantization unit 108 and the inverse orthogonal transform unit 109 respectively inverse-quantize and inverse-orthogonally transform intra-encoded pixels. The adder 110 adds output of the inverse orthogonal transform unit 109 and prediction images used in encoding pixel block corresponding thereto to deliver the added values thus obtained to the frame memory 111 to store them thereinto. In the case of pixel block to be intra-encoded, the intra prediction unit 113 reads out already encoded neighboring pixels stored in the frame memory 111 to generate prediction image. At this time, also with respect to the intra-prediction mode used for generation of prediction image, reversible encoding processing is implemented thereto at the reversible encoding unit 106 to output information thus processed in the state included into image compressed information.
Subsequently, outline of the configuration of an image information decoding apparatus corresponding to the above-described image information encoding apparatus 100 is shown in FIG. 2. The image information decoding apparatus 120 comprises, as shown in FIG. 2, a storage buffer 121, a reversible decoding unit 122, an inverse quantization unit 123, an inverse orthogonal transform unit 124, an adder 125, an image sorting buffer 126, a D/A (Digital/Analogue) converting unit 127, a motion prediction/compensation unit 128, a frame memory 129, and an intra-prediction unit 130.
In FIG. 2, the storage buffer 121 temporarily stores inputted image compressed information thereafter to transfer the image compressed information to the reversible decoding unit 122. The reversible decoding unit 122 implements processing such as variable length decoding or arithmetic decoding, etc. to the image compressed information on the basis of a predetermined format for image compressed information to deliver quantized transform coefficients to the inverse quantization unit 123. Moreover, in the case where corresponding frame is inter-encoded frame, the reversible decoding unit 122 also decodes motion vector information stored at the header portion of the image compressed information to deliver the information thus decoded to the motion prediction/compensation unit 128.
The inverse quantization unit 123 inverse-quantizes quantized transform coefficients delivered from the reversible decoding unit 122 to deliver the transform coefficients thus obtained to the inverse orthogonal transform unit 124. The inverse orthogonal transform unit 124 implements inverse orthogonal transform such as inverse discrete cosine transform or inverse Karhunen-Loeve transform, etc. to the transform coefficients on the basis of a predetermined format for image compressed information.
Here, in the case where corresponding frame is intra-encoded frame, the image information to which inverse orthogonal transform processing has been implemented are stored into the image sorting buffer 126, and are outputted after D/A converting processing at the D/A converting unit 127.
On the other hand, in the case where corresponding frame is inter-encoded frame, the motion prediction/compensation unit 128 generates reference image on the basis of motion vector information to which reversible decoding processing has been implemented and image information stored in the frame memory 129 to deliver the reference image thus generated to the adder 125. The adder 125 synthesizes the reference image and output of the inverse orthogonal transform unit 124. It is to be noted that since other processing are the same as those of the intra-encoded frame, their explanation will be omitted.
In this example, since the intra-predictive encoding system is employed in the JVT Codec, in the case where corresponding frame is intra-encoded frame, the intra-prediction unit 130 reads out image from the frame memory 129 to generate prediction image in accordance with intra-prediction mode to which reversible decoding processing has been implemented at the reversible decoding unit 122. The adder 125 adds output of the inverse orthogonal transform unit 124 and this prediction image.
The image information encoding apparatus 100 and the image information decoding apparatus 120 which have been explained above are disclosed in, e.g., Published Japanese Patent Application No. 2003-023637.
Meanwhile, in the JVT Codec (H.264|MPEG-4 AVC), as described above, in performing intra-encoding processing, there is employed such an intra predictive encoding system to generate prediction images from pixels around block to encode differences therebetween.
Here, in regard to luminance component, there are used two prediction systems of intra 4×4 prediction mode where prediction is performed on 4×4 pixel block basis and intra 16×16 prediction mode where prediction is performed on 16×16 pixel block (macro block) basis.
On the other hand, in regard to color difference components, predictions are performed on Cb, Cr respective 8×8 block basis. This predictive encoding method is the same as that in the intra 16×16 prediction mode, wherein this prediction mode is changed into the prediction mode of 8×8 block units. The prediction mode in the intra-predictive encoding of color difference is shown in FIG. 3. As shown in FIG. 3, at the JVT Codec, four prediction modes of
(a) Vertical mode (mode=0)
(b) Horizontal mode (mode=1)
(c) DC mode (mode=2)
(d) Plane Prediction mode (mode=3)
are defined. In accordance with prediction mode having least predictive difference (residual), prediction image is generated. The technique of generating prediction image in these four prediction modes will be explained below.
(a) Vertical Mode (Mode=0)
In the Vertical mode, pixels of adjacent upper side block of color difference block (in the case of 4:2:0 format, upper macro block) of color difference block are copied to allow the pixels thus copied to be prediction image of corresponding block. When pixels of adjacent upper side block are expressed as p[x, −1], prediction image predc of the color difference block in this case is represented by the following formula (1). It is to be noted that this mode can be used only in the case where adjacent upper side block exists.[1]predc[x,y]=p[x,−1] (x,y=0.7)  (1)
(b) Horizontal Mode (Mode=1)
In the Horizontal mode, pixels of adjacent left side block of color difference block (in the case of 4:2:0 format, left macro block) are copied to allow the pixels thus copied to be prediction image of corresponding block. When pixels of adjacent left side block are expressed as p[−1, y], prediction image predc of the color difference block in this case is represented by the following formula (2). It is to be noted that this mode can be used only in the case where adjacent left side block exists.[2]predc[x,y]=p[−1,y] (x,y=0.7)  (2)
(c) DC Mode (Mode=2)
In the DC mode, pixels of adjacent upper and left side blocks of color difference block are used to allow the mean (average) value thereof to be prediction image. It is to be noted that in the case where adjacent pixels do not exist, value 128 is used as prediction signal.
Namely, in the case of x, y=0.3, prediction image predc [x, y] is generated by using upper side pixel p[x, −1] and left side pixel p[−1, y] which are adjacent (in this example, x, y=0.3). More particularly, in four cases of the case (i) where pixel p[x, −1] and pixel p[−1, y] both exist, (ii) the case where pixel p[x, −1] exists and pixel p[−1, y] does not exist, (iii) the case where pixel p[x, −1] does not exist and pixel p[−1, y] exists, and (iv) the case where pixel p[x, −1] and pixel p[−1, y] do not both exist, prediction images are respectively generated in accordance with the following formulas (3) to (6).
                    [        3        ]                                                                                                                pred                c                            ⁡                              [                                  x                  ,                  y                                ]                                      =                          (                                                                    ∑                                                                  x                        ′                                            =                      0                                        3                                    ⁢                                      p                    ⁡                                          [                                                                        x                          ′                                                ,                                                  -                          1                                                                    ]                                                                      +                                                      ∑                                                                  y                        ′                                            =                      0                                        3                                    ⁢                                      p                    ⁡                                          [                                                                        -                          1                                                ,                                                  y                          ′                                                                    ]                                                                      +                4                            )                                >>          3                ⁢                                  ⁢                  (                      x            ,                          y              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                              )                                    (        3        )                                                                                    pred                c                            ⁡                              [                                  x                  ,                  y                                ]                                      =                          (                                                                    ∑                                                                  x                        ′                                            =                      0                                        3                                    ⁢                                      p                    ⁡                                          [                                                                        x                          ′                                                ,                                                  -                          1                                                                    ]                                                                      +                2                            )                                >>          2                ⁢                                  ⁢                  (                      x            ,                          y              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                              )                                    (        4        )                                                                                    pred                c                            ⁡                              [                                  x                  ,                  y                                ]                                      =                          (                                                                    ∑                                                                  y                        ′                                            =                      0                                        3                                    ⁢                                      p                    ⁡                                          [                                                                        -                          1                                                ,                                                  y                          ′                                                                    ]                                                                      +                2                            )                                >>          2                ⁢                                  ⁢                  (                      x            ,                          y              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                              )                                    (        5        )                                                                    pred              c                        ⁡                          [                              x                ,                y                            ]                                =          128                ⁢                                  ⁢                  (                      x            ,                          y              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                              )                                    (        6        )            
Similarly, in the case of x=4.7, y=0.3, prediction image predc [x, y] is generated by using upper side pixel p[x, −1] and left side pixel p[−1, y] which are adjacent (in this example, x=4.7, y=0.3). More particularly, in three cases of (i) the case where pixel p[x, −1] exists, (ii) the case where pixel p[x, −1] does not exist and pixel p[−1, y] exists, and (iii) the case where pixel p[x, −1] and pixel p[−1, y] do not both exist, prediction images are respectively generated in accordance with the following formulas (7) to (9).
                    [        4        ]                                                                                                                pred                c                            ⁡                              [                                  x                  ,                  y                                ]                                      =                          (                                                                    ∑                                                                  x                        ′                                            =                      4                                        7                                    ⁢                                      p                    ⁡                                          [                                                                        x                          ′                                                ,                                                  -                          1                                                                    ]                                                                      +                2                            )                                >>          2                ⁢                                  ⁢                  (                                    x              =                              4                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                7                                      ,                          y              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                              )                                    (        7        )                                                                                    pred                c                            ⁡                              [                                  x                  ,                  y                                ]                                      =                          (                                                                    ∑                                                                  y                        ′                                            =                      0                                        3                                    ⁢                                      p                    ⁡                                          [                                                                        -                          1                                                ,                                                  y                          ′                                                                    ]                                                                      +                2                            )                                >>          2                ⁢                                  ⁢                  (                                    x              =                              4                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                7                                      ,                          y              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                              )                                    (        8        )                                                      pred            c                    =          128                ⁢                                  ⁢                  (                                    x              =                              4                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                7                                      ,                          y              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                              )                                    (        9        )            
Similarly, in the case of x=0.3, y=4.7, prediction image predc [x, y] is generated by using upper side pixel p[x, −1] and left side pixel p[−1, y] which are adjacent (in this example, x=0.3, y=4.7). More particularly, in three cases of (i) the case where pixel p[−1, y] exists, (ii) the case where pixel p[x, −1] exists and pixel p [−1, y] does not exist, and (iii) the case where pixel p[x, −1] and pixel p[−1, y] do not both exist, prediction images are respectively generated in accordance with the following formulas (10) to (12).
                    [        5        ]                                                                                                                pred                c                            ⁡                              [                                  x                  ,                  y                                ]                                      =                          (                                                                    ∑                                                                  y                        ′                                            =                      4                                        7                                    ⁢                                      p                    ⁡                                          [                                                                        -                          1                                                ,                                                  y                          ′                                                                    ]                                                                      +                2                            )                                >>          2                ⁢                                  ⁢                  (                                    x              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                      ,                          y              =                              4                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                7                                              )                                    (        10        )                                                                                    pred                c                            ⁡                              [                                  x                  ,                  y                                ]                                      =                          (                                                                    ∑                                                                  x                        ′                                            =                      0                                        3                                    ⁢                                      p                    ⁡                                          [                                                                        x                          ′                                                ,                                                  -                          1                                                                    ]                                                                      +                2                            )                                >>          2                ⁢                                  ⁢                  (                                    x              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                      ,                          y              =                              4                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                7                                              )                                    (        11        )                                                      pred            c                    =          128                ⁢                                  ⁢                  (                                    x              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                      ,                          y              =                              4                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                7                                              )                                    (        12        )            
Similarly, in the case of x, y=4.7, prediction image predc [x, y] is generated by using upper side pixel p[x, −1] and left side pixel p[−1, y] which are adjacent (in this example, x, y=4.7). More particularly, in four cases of (i) the case where pixel p[x, −1] and pixel p[−1, y] both exist, (ii) the case where pixel p[x, −1] exists and pixel p[−1, y] does not exist, (iii) the case where pixel p[x, −1] does not exist and pixel p[−1, y] exists, and (iv) the case where pixel p[x, −1] and pixel p[−1, y] do not both exist, prediction images are respectively generated in accordance with the following formulas (13) to (16).
                    [        6        ]                                                                                                                pred                c                            ⁡                              [                                  x                  ,                  y                                ]                                      =                          (                                                                    ∑                                                                  x                        ′                                            =                      4                                        7                                    ⁢                                      p                    ⁡                                          [                                                                        x                          ′                                                ,                                                  -                          1                                                                    ]                                                                      +                                                      ∑                                                                  y                        ′                                            =                      4                                        7                                    ⁢                                      p                    ⁡                                          [                                                                        -                          1                                                ,                                                  y                          ′                                                                    ]                                                                      +                4                            )                                >>          3                ⁢                                  ⁢                  (                      x            ,                          y              =                              4                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                7                                              )                                    (        13        )                                                                    pred              c                        ⁡                          [                              x                ,                y                            ]                                =                      (                                                            ∑                                                            x                      ′                                        =                    4                                    7                                ⁢                                  p                  ⁡                                      [                                                                  x                        ′                                            ,                                              -                        1                                                              ]                                                              +              2                        )                          >>                  2          ⁢                                          ⁢                      (                          x              ,                              y                =                                  4                  ⁢                                                                          ⁢                  …                  ⁢                                                                          ⁢                  7                                                      )                                              (        14        )                                                                    pred              c                        ⁡                          [                              x                ,                y                            ]                                =                      (                                                            ∑                                                            y                      ′                                        =                    4                                    7                                ⁢                                  p                  ⁡                                      [                                                                  -                        1                                            ,                                              y                        ′                                                              ]                                                              +              2                        )                          >>                  2          ⁢                                          ⁢                      (                          x              ,                              y                =                                  4                  ⁢                                                                          ⁢                  …                  ⁢                                                                          ⁢                  7                                                      )                                              (        15        )                                                      pred            c                    ⁡                      [                          x              ,              y                        ]                          =                  128          ⁢                                          ⁢                      (                          x              ,                              y                =                                  4                  ⁢                                                                          ⁢                  …                  ⁢                                                                          ⁢                  7                                                      )                                              (        16        )            
(d) Plane Prediction Mode (Mode=3)
In the Plane Prediction mode, prediction image is plane-approximated from pixel of left side block (left macro block in the case of 4:2:0 format) and pixel of upper side block which are adjacent of color difference block to allow the prediction image thus obtained to be prediction image of corresponding block. When pixel of left side block and pixel of upper side block which are adjacent are respectively expressed as p[−1, y] and p[x, −1], prediction image predc of color difference in this case is represented by the following formula (17). Here, Clip1 indicates that clipping into the range from 0 to 255 is performed.
                    [        7        ]                                                                                                pred              c                        ⁡                          [                              x                ,                y                            ]                                =                      Clip            ⁢                                                  ⁢            1            ⁢                          (                                                (                                      a                    +                                          b                      ×                                              (                                                  x                          -                          3                                                )                                                              +                                          c                      ×                                              (                                                  y                          -                          3                                                )                                                              +                    16                                    )                                >>                5                            )                                      ⁢                                  ⁢                  (                      x            ,                          y              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                7                                              )                ⁢                                  ⁢        where                            (        17        )                                {                                                            a                =                                  16                  ×                                      (                                                                  p                        ⁡                                                  [                                                                                    -                              1                                                        ,                            7                                                    ]                                                                    +                                              p                        ⁡                                                  [                                                      7                            ,                                                          -                              1                                                                                ]                                                                                      )                                                                                                                                            b                  =                                      (                                                                  17                        ×                        H                                            +                      16                                        )                                                  >>                5                                                                                                          c                  =                                      (                                                                  17                        ×                        V                                            +                      16                                        )                                                  >>                5                                                                                        H                =                                                      ∑                                                                  x                        ′                                            =                      0                                        3                                    ⁢                                                            (                                                                        x                          ′                                                +                        1                                            )                                        ×                                          (                                                                        p                          ⁡                                                      [                                                                                          4                                +                                                                  x                                  ′                                                                                            ,                                                              -                                1                                                                                      ]                                                                          -                                                  p                          ⁡                                                      [                                                                                          2                                -                                                                  x                                  ′                                                                                            ,                                                              -                                1                                                                                      ]                                                                                              )                                                                                                                                              V                =                                                      ∑                                                                  y                        ′                                            =                      0                                        3                                    ⁢                                                            (                                                                        y                          ′                                                +                        1                                            )                                        ×                                          (                                                                        p                          ⁡                                                      [                                                                                          -                                1                                                            ,                                                              4                                +                                                                  y                                  ′                                                                                                                      ]                                                                          -                                                  p                          ⁡                                                      [                                                                                          -                                1                                                            ,                                                              2                                -                                                                  y                                  ′                                                                                                                      ]                                                                                              )                                                                                                                                          
In a manner as stated above, after intra-prediction of color difference component is performed by any one of the four prediction modes to generate prediction image, a difference signal between current pixel block and the prediction image is generated at the adder 103. The orthogonal transform unit 104 applies 4×4 integer transform to the difference signal of 8×8 blocks on 4×4 pixel block basis. When a difference signal obtained by subtracting prediction image from current pixel block is expressed as F4×4, 4×4 integer transform is represented by the following formula (18).
                    [        8        ]                                                                                  f                          4              ×              4                                =                                    T                              4                ×                4                                      ×                          F                              4                ×                4                                      ×                          T                              4                ×                4                            T                                      ⁢                                  ⁢        where        ⁢                                  ⁢                              T                          4              ×              4                                =                      (                                                            1                                                  1                                                  1                                                  1                                                                              2                                                  1                                                                      -                    1                                                                                        -                    2                                                                                                1                                                                      -                    1                                                                                        -                    1                                                                    1                                                                              1                                                                      -                    2                                                                    2                                                                      -                    1                                                                        )                                              (        18        )            
Further, in the JVT Codec, after 4×4 integer transform is performed, (0, 0) coefficients (DC coefficients) of four 4×4 blocks within 8×8 blocks are collected to constitute 2×2 blocks as shown in FIG. 4 to apply 2×2 Hadamard transform to the 2×2 blocks. This is because efficiency of intra-prediction used in color difference is not so high, and correlation is still left between (0, 0) coefficients of adjacent 4×4 blocks. In order to enhance (increase) encoding efficiency to more degree by utilizing this correlation, only (0, 0) coefficients of 4×4 blocks are collected to constitute 2×2 blocks to apply 2×2 Hadamard transform thereto. When chroma DC block of 2×2 is expressed as fdc2×2, chroma DC block fdc′ 2×2 after undergone 2×2 Hadamard transform is represented by the following formula (19).
                    [        9        ]                                                                                  fdc                          2              ×              2                        ′                    =                                    T                              2                ×                2                                      ×                          fdc                              2                ×                2                                      ×                          T                              2                ×                2                            T                                      ⁢                                  ⁢        where        ⁢                                  ⁢                              T                          2              ×              2                                =                                    1                              2                                      ⁢                          (                                                                    1                                                        1                                                                                        1                                                                              -                      1                                                                                  )                                                          (        19        )            
After integer transform processing, respective coefficients are quantized. When parameter for determining quantization coefficients of luminance is QPy, parameter QPc for determining quantization coefficients of color difference is calculated in a manner as described below.
Namely, first, QPy (which takes value ranging from 0 to 51) to be encoded in image compressed information and offset value chroma_qp_offset of quantization coefficients of color difference are used to calculate parameter QPi in accordance with the following formula (20). In this case, QPi is caused to undergo clipping into the range from 0 to 51.[10]QPi=QPy+chroma—qp_offset  (20)
Further, this QPi is used to determine parameter QPc of color difference from the Table 1 shown as below.
TABLE 1QPi<30 30 313233 3435 36 373839 40 414243444546474849 50 51QPc =QPi29 3031323233 34 3435 35 36363737 37 383838 3939 3939
Here, when values of respective AC coefficients before quantization are f, and values of respective AC coefficients after quantization are f′, values of quantized coefficients are represented by the following formula (21).
                    [        11        ]                                                                                                                f                ′                            ⁡                              [                                  i                  ,                  j                                ]                                      =                          (                                                                    f                    ⁡                                          [                                              i                        ,                        j                                            ]                                                        ×                                      Q                    ⁡                                          (                                                                                                    QP                            c                                                    ⁢                                                                                                          ⁢                          %                          ⁢                                                                                                          ⁢                          6                                                ,                        i                        ,                        j                                            )                                                                      +                r                            )                                >>                      (                          15              +                                                QP                  c                                /                6                                      )                          ⁢                                  ⁢                  (                      i            ,                          j              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                              )                ⁢                                  ⁢        where                            (        21        )                                {                                                                                                                                                                          Q                          ⁡                                                      (                                                                                          QP                                ⁢                                                                                                                                  ⁢                                %                                ⁢                                                                                                                                  ⁢                                6                                                            ,                              i                              ,                              j                                                        )                                                                          =                                                ⁢                                                                              quantMat                            ⁢                                                                                                                  [                                                          QP                              ⁢                                                                                                                          ⁢                              %                              ⁢                                                                                                                          ⁢                              6                                                        ]                                                    ⁡                                                      [                            0                            ]                                                                                              ,                                                                        (                                                      i                            ,                            j                                                    )                                                ∈                                                                                                                                                                              ⁢                                              {                                                                              (                                                          0                              ,                              0                                                        )                                                    ,                                                      (                                                          0                              ,                              2                                                        )                                                    ,                                                      (                                                          2                              ,                              0                                                        )                                                    ,                                                      (                                                          2                              ,                              2                                                        )                                                                          }                                                                                                                                                                                =                                                ⁢                                                                              quantMat                            ⁢                                                                                                                  [                                                          QP                              ⁢                                                                                                                          ⁢                              %                              ⁢                                                                                                                          ⁢                              6                                                        ]                                                    ⁡                                                      [                            1                            ]                                                                                              ,                                                                        (                                                      i                            ,                            j                                                    )                                                ∈                                                                                                                                                                              ⁢                                              {                                                                              (                                                          1                              ,                              1                                                        )                                                    ,                                                      (                                                          1                              ,                              3                                                        )                                                    ,                                                      (                                                          3                              ,                              1                                                        )                                                    ,                                                      (                                                          3                              ,                              3                                                        )                                                                          }                                                                                                                                                                                =                                                ⁢                                                                              quantMat                            ⁢                                                                                                                  [                                                          QP                              ⁢                                                                                                                          ⁢                              %                              ⁢                                                                                                                          ⁢                              6                                                        ]                                                    ⁡                                                      [                            2                            ]                                                                                              ,                      otherwise                                                                                                                                                                                    quantMat                    ⁢                                                                                  [                    6                    ]                                    ⁡                                      [                    3                    ]                                                  =                                  [                                                                                    13107                                                                    5243                                                                    8224                                                                                                            11651                                                                    4660                                                                    7358                                                                                                            10486                                                                    4143                                                                    6554                                                                                                            9198                                                                    3687                                                                    5825                                                                                                            8322                                                                    3290                                                                    5243                                                                                                            7384                                                                    2943                                                                    4660                                                                              ]                                                                                                    
On the other hand, when values of respective DC coefficients before quantization are fdc, and values of respective DC coefficients after quantization are fdc′, values of quantized coefficients are represented by the following formula (22). In this case, r in the formula (22) is constant for rounding processing.[12]fdc′[i,j]=(fdc[i,j]×Q(QPc%6,0,0)+r)>>(16+QPc/6) (i,j=0.1)  (22)
Moreover, when AC coefficients after inverse quantization are f″, inverse quantization of AC coefficients is represented by the following formula (23).
                    [        13        ]                                                                                                f              ″                        ⁡                          [                              i                ,                j                            ]                                =                                    (                                                                                          f                      ′                                        ⁡                                          [                                              i                        ,                        j                                            ]                                                        ×                                      IQ                    ⁡                                          (                                                                                                    QP                            c                                                    ⁢                                                                                                          ⁢                          %                          ⁢                                                                                                          ⁢                          6                                                ,                        i                        ,                        j                                            )                                                                      +                r                            )                        ⁢                                                  ⁢                          <<                              (                                                      QP                    c                                    /                  6                                )                                                    ⁢                                  ⁢                  (                      i            ,                          j              =                              0                ⁢                                                                  ⁢                …                ⁢                                                                  ⁢                3                                              )                ⁢                                  ⁢        where                            (        23        )                                {                                                                                                                                                                          IQ                          ⁡                                                      (                                                                                          QP                                ⁢                                                                                                                                  ⁢                                %                                ⁢                                                                                                                                  ⁢                                6                                                            ,                              i                              ,                              j                                                        )                                                                          =                                                ⁢                                                                              iquantMat                            ⁢                                                                                                                  [                                                          QP                              ⁢                                                                                                                          ⁢                              %                              ⁢                                                                                                                          ⁢                              6                                                        ]                                                    ⁡                                                      [                            0                            ]                                                                                              ,                                                                        (                                                      i                            ,                            j                                                    )                                                ∈                                                                                                                                                                              ⁢                                              {                                                                              (                                                          0                              ,                              0                                                        )                                                    ,                                                      (                                                          0                              ,                              2                                                        )                                                    ,                                                      (                                                          2                              ,                              0                                                        )                                                    ,                                                      (                                                          2                              ,                              2                                                        )                                                                          }                                                                                                                                                                                =                                                ⁢                                                                              iquantMat                            ⁢                                                                                                                  [                                                          QP                              ⁢                                                                                                                          ⁢                              %                              ⁢                                                                                                                          ⁢                              6                                                        ]                                                    ⁡                                                      [                            1                            ]                                                                                              ,                                                                        (                                                      i                            ,                            j                                                    )                                                ∈                                                                                                                                                                              ⁢                                              {                                                                              (                                                          1                              ,                              1                                                        )                                                    ,                                                      (                                                          1                              ,                              3                                                        )                                                    ,                                                      (                                                          3                              ,                              1                                                        )                                                    ,                                                      (                                                          3                              ,                              3                                                        )                                                                          }                                                                                                                                                                                =                                                ⁢                                                                              iquantMat                            ⁢                                                                                                                  [                                                          QP                              ⁢                                                                                                                          ⁢                              %                              ⁢                                                                                                                          ⁢                              6                                                        ]                                                    ⁡                                                      [                            2                            ]                                                                                              ,                      otherwise                                                                                                                                                                                    iquantMat                    ⁢                                                                                  [                    6                    ]                                    ⁡                                      [                    3                    ]                                                  =                                  [                                                                                    10                                                                    16                                                                    13                                                                                                            11                                                                    18                                                                    14                                                                                                            13                                                                    20                                                                    16                                                                                                            14                                                                    23                                                                    18                                                                                                            16                                                                    25                                                                    20                                                                                                            18                                                                    29                                                                    23                                                                              ]                                                                                                    
On the other hand, when inverse-quantized DC coefficients are fdc″, inverse quantization of DC coefficients is represented by the following formula (24) in the case where QPc is 6 (six) or more, and is represented by the following formula (25) in the case where QPc is less than 6 (six).[14]fdc″[i,j]=(fdc′[i,j]×IQ(QPc%6,i,j))<<(QPc/6−1) (i,j=0.3)  (24)fdc″[i,j]=(fdc′[i,j]×IQ(QPc%6,i,j))>>1 (i,j=0.3)  (25)
While intra-predictive encoding processing is performed in the JVT Codec in a manner as stated above, there was the problem that even if the above-mentioned technique is used, since block size is small in the intra-predictive encoding of color difference, encoding efficiency is inferior as compared to luminance.
In addition, there was the problem that the above-mentioned technique only complies with 4:2:0 format and YCbCr color space, so encoding cannot be performed in the case of 4:2:2 format, 4:4:4 format, RGB color space, XYZ color space, etc.